package org.jeecg.modules.oa.controller;

import cn.hutool.system.UserInfo;
import io.netty.util.internal.StringUtil;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpRequest;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.SsoUtil;
import org.jeecg.common.util.StringUtils;
import org.jeecg.modules.oa.entity.*;
import org.jeecg.modules.oa.service.IAlterAttendanceService;
import org.jeecg.modules.oa.service.IAttendanceManagementService;
import org.jeecg.modules.system.aspect.DictAspect;
import org.jeecg.modules.system.entity.SysUser;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

@RestController
@Slf4j
@RequestMapping("/b/attendance/app")
@Api(tags="打卡")
public class AppAttendanceController {

    @Autowired
    private DictAspect dictAspect;
    @Autowired
    private IAttendanceManagementService attendanceManagementService;
    @Autowired
    private IAlterAttendanceService alterAttendanceService;
    @Autowired
    private ISysUserService sysUserService;
    private static final Double STANDARD_WORK_HOURS = 8.0;

    private static int interval = 15;

    /**
     * 前一次考勤记录取得
     *
     * @param clockRequestEntity
     * @return
     */
    @GetMapping(value = "findPre")
    public Result findPre(ClockRequestEntity clockRequestEntity,HttpServletRequest request) {
        LoginUser user = SsoUtil.getLoginUser();
        if (user == null || StringUtils.isBlank(user.getId())){
            return Result.error(99,"登录失效");
        }
        request.setAttribute("tenantId",user.getTenantId());
        AttendanceManagement attendance = new AttendanceManagement();
        attendance.setCreateBy(user.getId());
        attendance = attendanceManagementService.findPre(attendance);
        AttendanceSite attendancePosition = null; //attendanceSiteService.getSiteByOfficeId(user);
        int resCode = 0;
        // 显示情况判定
        // 1.初期点击【考勤打卡】时
        if (StringUtils.isEmpty(clockRequestEntity.getClockModel())) {
            if (attendance == null) {
                attendance = new AttendanceManagement();
                attendance.setShowModel("0"); //上班model
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
                // 设置显示的说明文字
                attendance.setShowExplain1("上次的打卡记录");
                attendance.setShowExplain2("您还没有打卡记录");
                attendance.setId("0");
                //设置打卡间隔时长:15分钟
                attendance.setInterval(interval);
                attendance.setAttendanceSiteFlag("0");
                if(null != attendancePosition){
                    attendance.setRouterName(attendancePosition.getName());
                    attendance.setIps(attendancePosition.getIps());
                    attendance.setAttendanceSiteFlag("1");
                }
                return Result.ok(attendance,"获取成功");
            }
            // 设置显示的说明文字
            attendance.setShowExplain1("上次的打卡记录");
            AlterAttendance alterAttendance = attendance.getAlterAttendance();
            // 1.1.1 判定最近一次打卡的记录的状态
            if (attendance.getClockInTime() != null && attendance.getClockOutTime() != null) {// 上下班都打卡了
                // 设置显示的Tab -上班
                attendance.setShowModel("0");
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
            } else if (attendance.getClockInTime() != null && attendance.getClockOutTime() == null) { // 上班打卡、下班未打卡
                if (alterAttendance == null) { // 无补卡记录
                    // 设置显示的Tab -下班
                    attendance.setShowModel("1");
                    // 打卡按钮可点击
                    attendance.setBtnFlg("0");
                    // 说明2
                    attendance.setShowExplain2("下班未打卡");
                    // 说明3
                    attendance.setShowExplain3("若需补打卡，请切换至上班打卡界面");
                } else {
                    if (alterAttendance.getAlterTime() != null && "1".equals(alterAttendance.getAlterType())) { // 下班有补卡
                        // 设置显示的Tab -上班
                        attendance.setShowModel("0");
                        // 打卡按钮可点击
                        attendance.setBtnFlg("0");
                        // 显示补下班卡状态标记
                        attendance.setAlterBtnFlg("3");
                        // 显示审核的状态
//                        attendance.getAlterAttendance().getStatusName();
                        // 把下班补卡的时间--赋值给打卡的下班时间 （只是显示用）
                        attendance.setClockOutTime(alterAttendance.getAlterTime());
                    } else {
                        // TODO 不整合数据的情况 目前不做处理
//                        res.setResCode("3");
                        resCode = 3;
                    }
                }

            } else if (attendance.getClockOutTime() != null && attendance.getClockInTime() == null) { // 上班未打卡、下班打卡了
                if (alterAttendance == null) { // 上班无补卡
                    // 设置显示的Tab - 下班
                    attendance.setShowModel("1");
                    // 打卡按钮不可点击
                    attendance.setBtnFlg("1");
                    // 说明2
                    attendance.setShowExplain2("上班未打卡");
                    // 说明3
                    attendance.setShowExplain3("请补完上一次的上班卡后再打上班卡 ");
                    // 显示补上班卡按钮
                    attendance.setAlterBtnFlg("0");
                } else {
                    if (alterAttendance.getAlterTime() != null && "0".equals(alterAttendance.getAlterType())) { // 上班有补卡
                        // 设置显示的Tab -上班
                        attendance.setShowModel("0");
                        // 打卡按钮可点击
                        attendance.setBtnFlg("0");
                        // 显示补上班卡状态标记
                        attendance.setAlterBtnFlg("2");
                        // 显示审核的状态
//                        attendance.getAlterAttendance().getStatusName();
                        // 把上班补卡的时间--赋值给打卡的上班时间 （只是显示用）
                        attendance.setClockInTime(alterAttendance.getAlterTime());
                    } else {
                        // TODO 不整合数据的情况 目前不做处理
//                        res.setResCode("4");
                        resCode = 4;
                    }
                }
            } else { // 数据不整合时
                // 设置显示的Tab -上班
                attendance.setShowModel("0");
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
//                res.setResCode("5");
                resCode = 5;
            }
        }
        // 上班打卡model
        if ("0".equals(clockRequestEntity.getClockModel())) {
            if (attendance == null) {
//                res.setResCode("0");
                attendance = new AttendanceManagement();
                // 设置显示的说明文字
                attendance.setShowExplain1("上次的打卡记录");
                attendance.setShowExplain2("您还没有打卡记录");
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
                // 原样输出点击的model
                attendance.setShowModel("0");
                attendance.setId("0");
                //设置打卡间隔时长:15分钟
                attendance.setInterval(interval);
                attendance.setAttendanceSiteFlag("0");
                if(null != attendancePosition){
                    attendance.setRouterName(attendancePosition.getName());
                    attendance.setIps(attendancePosition.getIps());
                    attendance.setAttendanceSiteFlag("1");
                }
                return Result.ok(attendance,"获取成功");
            }
            // 设置显示的说明文字
            attendance.setShowExplain1("上次的打卡记录");
            // 原样输出点击的model
            attendance.setShowModel("0");
            AlterAttendance alterAttendance = attendance.getAlterAttendance();
            if (attendance.getClockInTime() != null && attendance.getClockOutTime() != null) {// 上下班都打卡了
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
            } else if (attendance.getClockInTime() != null && attendance.getClockOutTime() == null) { // 上班打卡、下班未打卡
                if (alterAttendance == null) { // 无补卡记录
                    // 打卡按钮不可点击
                    attendance.setBtnFlg("1");
                    // 说明2
                    attendance.setShowExplain2("下班未打卡");
                    // 显示可补下班卡状态标记
                    attendance.setAlterBtnFlg("1");
                } else {
                    if (alterAttendance.getAlterTime() != null && "1".equals(alterAttendance.getAlterType())) { // 下班有补卡
                        // 打卡按钮可点击
                        attendance.setBtnFlg("0");
                        // 显示补下班卡状态标记
                        attendance.setAlterBtnFlg("3");
                        // 显示审核的状态
//                        attendance.getAlterAttendance().getStatusName();
                        // 把下班补卡的时间--赋值给打卡的下班时间 （只是显示用）
                        attendance.setClockOutTime(alterAttendance.getAlterTime());
                    } else {
                        // TODO 不整合数据的情况 目前不做处理
//                        res.setResCode("6");
                        resCode = 6;
                    }
                }
            } else if (attendance.getClockOutTime() != null && attendance.getClockInTime() == null) { // 上班未打卡、下班打卡了
                if (alterAttendance == null) { // 上班无补卡
                    // 打卡按钮不可点击
                    attendance.setBtnFlg("1");
                    // 说明2
                    attendance.setShowExplain2("上班未打卡");
                    // 显示补上班卡按钮
                    attendance.setAlterBtnFlg("0");
                    // 说明3
                    attendance.setShowExplain3("请补完上一次的上班卡后再打上班卡 ");
                } else {
                    if (alterAttendance.getAlterTime() != null && "0".equals(alterAttendance.getAlterType())) { // 上班有补卡
                        // 打卡按钮可点击
                        attendance.setBtnFlg("0");
                        // 显示补上班卡状态标记
                        attendance.setAlterBtnFlg("2");
                        // 显示审核的状态
//                        attendance.getAlterAttendance().getStatusName();
                        // 把上班补卡的时间--赋值给打卡的上班时间 （只是显示用）
                        attendance.setClockInTime(alterAttendance.getAlterTime());
                    } else {
                        // TODO 不整合数据的情况 目前不做处理
//                        res.setResCode("7");
                        resCode = 7;
                    }
                }
            } else { // TODO 数据不整合
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
//                res.setResCode("8");
                resCode = 8;
            }
        }
        //打下班卡model
        if ("1".equals(clockRequestEntity.getClockModel())) {
            if (attendance == null) {
                attendance = new AttendanceManagement();
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
                // 设置显示的说明文字
                attendance.setShowExplain1("上次的打卡记录");
                attendance.setShowExplain2("您还没有打卡记录");
                // 原样输出点击的model
                attendance.setShowModel("1");
                attendance.setId("0");
                //设置打卡间隔时长:15分钟
                attendance.setInterval(interval);
                attendance.setAttendanceSiteFlag("0");
                if(null != attendancePosition){
                    attendance.setRouterName(attendancePosition.getName());
                    attendance.setIps(attendancePosition.getIps());
                    attendance.setAttendanceSiteFlag("1");
                }
                return Result.ok(2,attendance);
            }
            // 设置显示的说明文字
            attendance.setShowExplain1("上次的打卡记录");
            // 原样输出点击的model
            attendance.setShowModel("1");
            AlterAttendance alterAttendance = attendance.getAlterAttendance();
            if (attendance.getClockInTime() != null && attendance.getClockOutTime() != null) {// 上下班都打卡了
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
                // 显示更新按钮
                attendance.setUpdateBtnFlg("0");
            } else if (attendance.getClockInTime() != null && attendance.getClockOutTime() == null) { // 上班打卡、下班未打卡
                if (alterAttendance == null) { // 无补打卡记录
                    // 说明2
                    attendance.setShowExplain2("下班未打卡");
                    // 说明3
                    attendance.setShowExplain3("若需补打卡，请切换至上班打卡界面");
                    // 打卡按钮可点击
                    attendance.setBtnFlg("0");
                } else {
                    if (alterAttendance.getAlterTime() != null && "1".equals(alterAttendance.getAlterType())) { // 下班有补卡
                        // 打卡按钮可点击
                        attendance.setBtnFlg("0");
                        // 说明3
                        attendance.setShowExplain3("上班未打卡,打完下班卡后,可手动补上班卡 ");
                        // 显示已补下班卡状态标记
                        attendance.setAlterBtnFlg("3");
                        // 显示审核的状态
//                        attendance.getAlterAttendance().getStatusName();
                        // 把下班补卡的时间--赋值给打卡的下班时间 （只是显示用）
                        attendance.setClockOutTime(alterAttendance.getAlterTime());
                    } else {
                        // TODO 不整合数据的情况 目前不做处理
//                        res.setResCode("9");
                        resCode = 9;
                    }
                }
            } else if (attendance.getClockOutTime() != null && attendance.getClockInTime() == null) { // 上班未打卡、下班打卡了
                if (alterAttendance == null) { // 无补打卡记录
                    // 打卡按钮不可点击
                    attendance.setBtnFlg("1");
                    // 说明2
                    attendance.setShowExplain2("上班未打卡");
                    // 说明3
                    attendance.setShowExplain3("请补完上一次的上班卡后再打下班卡 ");
                    // 显示可补上班卡
                    attendance.setAlterBtnFlg("0");
                    // 显示可更新下班卡
                    attendance.setUpdateBtnFlg("0");
                } else {
                    if (alterAttendance.getAlterTime() != null && "0".equals(alterAttendance.getAlterType())) { // 上班有补卡
                        // 打卡按钮可点击
                        attendance.setBtnFlg("0");
                        // 显示补上班卡状态标记
                        attendance.setAlterBtnFlg("2");
                        // 显示审核的状态
//                        attendance.getAlterAttendance().getStatusName();
                        // 说明3
                        attendance.setShowExplain3("上班未打卡,打完下班卡后,可手动补上班卡 ");
                        // 把上班补卡的时间--赋值给打卡的上班时间 （只是显示用）
                        attendance.setClockInTime(alterAttendance.getAlterTime());
                        // 显示可更新下班卡
                        attendance.setUpdateBtnFlg("0");
                    } else {
                        // TODO 不整合数据的情况 目前不做处理
//                        res.setResCode("10");
                        resCode = 10;
                    }
                }
            } else {
                // TODO 数据不整合
                // 打卡按钮可点击
                attendance.setBtnFlg("0");
                resCode = 11;
            }
        }
//        if (resCode == 0) {
//            res.setResCode("0");
//        }
        if(StringUtils.isEmpty(attendance.getId())){
            attendance.setId("1");
        }
        //设置打卡间隔时长:15分钟
        attendance.setInterval(interval);
        /*UserInfo userInfo = userInfoService.getByUserId(user.getId());
        if(null == userInfo){
            attendance.setShowExplain3("请于本周日前上传完善个人身份信息\n");
        } else if(!"0".equals(userInfo.getInfoStatus())){
            log.info(userInfo.getInfoStatus());
            attendance.setShowExplain3("请于本周日前上传完善个人身份信息\n");
        }*/
        attendance.setAttendanceSiteFlag("0");
        if(null != attendancePosition){
            attendance.setRouterName(attendancePosition.getName());
            attendance.setIps(attendancePosition.getIps());
            attendance.setAttendanceSiteFlag("1");
        }
        return Result.ok(resCode,attendance);
    }






    /**
     * 新版打卡接口
     *
     * @param clockRequestEntity
     * @return
     */
    @PostMapping(value = "save")
    public Result save(ClockRequestEntity clockRequestEntity , String routerName , String ips) {
        LoginUser user = SsoUtil.getLoginUser();
        if (user == null || StringUtils.isBlank(user.getId())){
            return Result.error(99,"登录失效");
        }
        Result res = new Result();
        //人员档案
//        PeopleManagement  people = peopleManagementService.get(user.getUserId());
        //身份证信息
//        UserInfo userInfo = userInfoService.getByUserId(user.getId());
//        if(people != null){
//            if(StringUtils.isEmpty(people.getIdCardPhotoPath()) || StringUtils.isEmpty(people.getIdCardPhotoPath2())) {
//                if(null == userInfo){
//                    res.setResCode("2");
//                    res.setResMsg("请及时上传完善个人身份信息");
//                    return res;
//                } else if(!"2".equals(userInfo.getInfoStatus()) && !"0".equals(userInfo.getInfoStatus())){
//                    res.setResCode("2");
//                    res.setResMsg("请及时上传完善个人身份信息");
//                    return res;
//                }
//            }
//        } else {
//            if(null == userInfo){
//                res.setResCode("2");
//                res.setResMsg("未找到用户信息，打卡失败");
//                return res;
//            }
//        }
        AttendanceManagement newAtte = new AttendanceManagement();
        //如果需要路由器打卡，就在表里配置办公室路由器以及定位信息，下面就会根据表里的信息判断是否是当前路由器
        AttendanceSite attendanceSite = null; //attendanceSiteService.getPostionByOfficeId(user);
        if(null != attendanceSite){
            if(!attendanceSite.getIps().contains(ips)){
                Date clockTime = new Date();
                // 设置用户编号
                newAtte.setUserId(user.getId());
                // 设置打卡时间
                newAtte.setClockInTime(clockTime);
                // 设置打卡头像
                newAtte.setClockInImg(clockRequestEntity.getClockImg());
                // 设置上班打卡经度坐标
                newAtte.setInLongitude(clockRequestEntity.getLongitude());
                // 设置上班打卡纬度坐标
                newAtte.setInLatitude(clockRequestEntity.getLatitude());
                // 设置打卡位置
                newAtte.setInPosition(clockRequestEntity.getClockPosition());
                //数据记录下来 但是是隐藏数据
                newAtte.setDelFlag("1");
                // 未打卡，插入数据
                attendanceManagementService.save(newAtte);
                return Result.error(2,"路由器名称不匹配，打卡失败");
            }
        }
        //临时控制新用户没有记录 前端崩掉了的情况
        if("1".equals(clockRequestEntity.getAttendanceId()) || "0".equals(clockRequestEntity.getAttendanceId())){
            clockRequestEntity.setAttendanceId("");
        }
        // 记录打卡时间
        Date clockTime = new Date();
        // 打上班卡	 * 上班：0  下班：1  更新上班：2  更新下班：3
        if ("0".equals(clockRequestEntity.getClockModel())) {
            // 设置用户编号
            newAtte.setUserId(user.getId());
            // 设置打卡时间
            newAtte.setClockInTime(clockTime);
            // 设置打卡头像
            newAtte.setClockInImg(clockRequestEntity.getClockImg());
            // 设置上班打卡经度坐标
            newAtte.setInLongitude(clockRequestEntity.getLongitude());
            // 设置上班打卡纬度坐标
            newAtte.setInLatitude(clockRequestEntity.getLatitude());
            // 设置打卡位置
            newAtte.setInPosition(clockRequestEntity.getClockPosition());
            Calendar ca = Calendar.getInstance();
            ca.setTime(clockTime);
            int hour = ca.get(Calendar.HOUR_OF_DAY);
            if (hour > 9 && ca.get(Calendar.MINUTE) > 1) { // 迟到
                newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_2);
            } else {
                //未打卡
                newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_4);
            }
            // 插入数据
            attendanceManagementService.save(newAtte);
            //设置切换到下班打卡model
            newAtte.setShowModel("1");
            res.setCode(0);
            res.setMessage("上班打卡成功");
            res.setResult(newAtte);
        }

        //打下班卡
        if("1".equals(clockRequestEntity.getClockModel())){
            //	判断是否有前次考勤id
            if(StringUtils.isEmpty(clockRequestEntity.getAttendanceId())){
                // 新插入一条
                // 设置用户编号
                newAtte.setUserId(user.getId());
                // 设置打卡时间
                newAtte.setClockOutTime(clockTime);
                // 设置打卡头像
                newAtte.setClockOutImg(clockRequestEntity.getClockImg());
                // 设置下班打卡经度坐标
                newAtte.setOutLongitude(clockRequestEntity.getLongitude());
                // 设置下班打卡纬度坐标
                newAtte.setOutLatitude(clockRequestEntity.getLatitude());
                // 设置打卡位置
                newAtte.setOutPosition(clockRequestEntity.getClockPosition());
                // 未打卡，插入数据
                Calendar ca = Calendar.getInstance();
                ca.setTime(clockTime);
                int hour = ca.get(Calendar.HOUR_OF_DAY);
                if (hour < 17) { // 早退
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_3);
                } else {
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_1);
                }
                attendanceManagementService.save(newAtte);
                res.setCode(0);
                res.setMessage("下班打卡成功");
                //该情况不用跳转,为统一也设置下model,设置下班model
                newAtte.setShowModel("1");
                res.setResult(newAtte);
            } else {
                AttendanceManagement attendance = attendanceManagementService.getById(clockRequestEntity.getAttendanceId());
                if(attendance != null && ((attendance.getClockInTime() != null && attendance.getClockOutTime() != null)
                        || (attendance.getClockInTime() !=null && attendance.getClockOutTime() == null && attendance.getAlterAttendance() != null && attendance.getAlterAttendance().getAlterTime() != null)
                        || (attendance.getClockInTime() == null && attendance.getClockInTime() != null && attendance.getAlterAttendance() != null && attendance.getAlterAttendance().getAlterTime() != null))){
                    // 新插入一条
                    // 设置用户编号
                    newAtte.setUserId(user.getId());
                    // 设置打卡时间
                    newAtte.setClockOutTime(clockTime);
                    // 设置打卡头像
                    newAtte.setClockOutImg(clockRequestEntity.getClockImg());
                    // 设置下班打卡经度坐标
                    newAtte.setOutLongitude(clockRequestEntity.getLongitude());
                    // 设置下班打卡纬度坐标
                    newAtte.setOutLatitude(clockRequestEntity.getLatitude());
                    // 设置打卡位置
                    newAtte.setOutPosition(clockRequestEntity.getClockPosition());
                    // 未打卡，插入数据
                    Calendar ca = Calendar.getInstance();
                    ca.setTime(clockTime);
                    int hour = ca.get(Calendar.HOUR_OF_DAY);
                    if (hour < 17) { // 早退
                        newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_3);
                    } else {
                        newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_1);
                    }
                    attendanceManagementService.save(newAtte);
                    res.setCode(0);
                    res.setMessage("下班打卡成功");
                    //该情况不用跳转,为统一也设置下model,设置下班model
                    newAtte.setShowModel("1");
                    res.setResult(newAtte);
                } else {
                    newAtte = attendanceManagementService.getById(clockRequestEntity.getAttendanceId());
                    // 设置打卡时间
                    newAtte.setClockOutTime(clockTime);
                    // 设置打卡头像
                    newAtte.setClockOutImg(clockRequestEntity.getClockImg());
                    // 设置下班打卡经度坐标
                    newAtte.setOutLongitude(clockRequestEntity.getLongitude());
                    // 设置下班打卡纬度坐标
                    newAtte.setOutLatitude(clockRequestEntity.getLatitude());
                    // 设置打卡位置
                    newAtte.setOutPosition(clockRequestEntity.getClockPosition());
                    Calendar ca = Calendar.getInstance();
                    ca.setTime(clockTime);
                    int hour = ca.get(Calendar.HOUR_OF_DAY);
                    if (hour < 17) { // 早退
                        newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_3);
                    } else {
                        newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_1);
                    }
                    attendanceManagementService.updateAll(newAtte);
                    res.setCode(0);
                    res.setMessage("下班打卡成功");
                    //切换到上班model
                    newAtte.setShowModel("0");
                    res.setResult(newAtte);
                }
            }
        }
        // 补打上班卡
        if("2".equals(clockRequestEntity.getClockModel())){
            //判断是否有传入前次的考勤记录id
            if(StringUtils.isEmpty(clockRequestEntity.getAttendanceId())){
                return Result.error(2,"无前次考勤信息,补卡失败");
            }
            //判断补卡考勤时间
            Date alterInTime = clockRequestEntity.getAlterTime();
            if(alterInTime == null){
                return Result.error(2,"补卡时间为空,补卡失败");
            }
            newAtte = attendanceManagementService.getById(clockRequestEntity.getAttendanceId());
            if(newAtte == null){
                return Result.error(2,"无前次考勤信息,补卡失败");
            }
            Date clickOutTime = newAtte.getClockOutTime();
            // 补卡的上班时间大于 原先打卡的下班时间
            if(clickOutTime != null && alterInTime.compareTo(clickOutTime) >= 0 ){
                return Result.error(2,"补卡上班时间大于下班时间,补卡失败");
            }
            Date nowTime  = new Date();
            if(alterInTime.compareTo(nowTime) > 0){
                return Result.error(2,"补卡时间大于当前时间,补卡失败");
            }
            AlterAttendance alterAttendance = new AlterAttendance();
            alterAttendance.setAlterTime(alterInTime);
            alterAttendance.setAlterType("0");
            alterAttendance.setAttendanceId(clockRequestEntity.getAttendanceId());
            alterAttendance.setStatus("1"); // 待审核
            alterAttendance.setRemarks(clockRequestEntity.getAlterReason());
            alterAttendanceService.save(alterAttendance);
            //该情况不用跳转,为统一也设置下model,设置下班model
            newAtte.setShowModel("1");
            return Result.ok(newAtte,"补打上班卡成功");
        }
        // 补打下班卡
        if("3".equals(clockRequestEntity.getClockModel())){
            //判断是否有前次的考勤记录id
            if(StringUtils.isEmpty(clockRequestEntity.getAttendanceId())){
                return Result.error(2,"无前次考勤信息,补卡失败");
            }
            //判断补卡考勤时间
            Date alterOutTime = clockRequestEntity.getAlterTime();
            if(alterOutTime == null){
                return Result.error(2,"补卡时间为空,补卡失败");
            }
            newAtte = attendanceManagementService.getById(clockRequestEntity.getAttendanceId());
            if(newAtte == null){
                return Result.error(2,"无前次考勤信息,补卡失败");
            }
            Date clickInTime = newAtte.getClockInTime();
            // 补卡的下班时间小于 原先打卡的上班时间
            if(clickInTime != null && alterOutTime.compareTo(clickInTime) < 0 ){
                return Result.error(2,"补卡下班时间小于上班时间,补卡失败");
            }
            Date nowTime  = new Date();
            if(alterOutTime.compareTo(nowTime) > 0){
                return Result.error(2,"补卡时间大于当前时间,补卡失败");
            }
            AlterAttendance alterAttendance = new AlterAttendance();
            alterAttendance.setAlterTime(alterOutTime);
            alterAttendance.setAlterType("1"); //补下班
            alterAttendance.setAttendanceId(clockRequestEntity.getAttendanceId());
            alterAttendance.setStatus("1"); // 待审核
            alterAttendance.setRemarks(clockRequestEntity.getAlterReason());
            alterAttendanceService.save(alterAttendance);
            //该情况不用跳转,为统一也设置下model,设置上班model
            newAtte.setShowModel("0");
            return Result.ok(newAtte,"补打下班卡成功");
        }
        //更新下班打卡
        if("4".equals(clockRequestEntity.getClockModel())){
            //判断是否有前次的考勤记录id
            if(StringUtils.isEmpty(clockRequestEntity.getAttendanceId())){
                return Result.error(2,"无前次考勤信息,更新打卡失败");
            }
            newAtte = attendanceManagementService.getById(clockRequestEntity.getAttendanceId());
            if(newAtte == null){
                return Result.error(2,"无前次考勤信息,补卡失败");
            }
            newAtte.setOutLatitude(clockRequestEntity.getLatitude());
            newAtte.setOutLongitude(clockRequestEntity.getLongitude());
            newAtte.setOutPosition(clockRequestEntity.getClockPosition());
            newAtte.setClockOutTime(new Date());
            attendanceManagementService.updateAll(newAtte);
            res.setCode(0);
            res.setMessage("更新打卡成功");
            //该情况不用跳转,为统一也设置下model,设置下班model
            newAtte.setShowModel("1");
            res.setResult(newAtte);
        }
        //设置打卡间隔时长  15分钟
        newAtte.setInterval(interval);

//        //临时提醒用 TODO
//        if(null == userInfo){
//            res.setResMsg("请于本周日前上传完善个人身份信息");
//        } else if(!"0".equals(userInfo.getInfoStatus())){
//            log.info(userInfo.getInfoStatus());
//            res.setResMsg("请于本周日前上传完善个人身份信息");
//        }
        return res;
    }



    /**
     * APP打卡
     */
    @RequestMapping("punchCard")
    public Result<?> punchCard(ClockRequestEntity clockRequestEntity){
        Date clockTime = new Date();
        Result res = new Result();
        SysUser user = sysUserService.getUserByLoginName(clockRequestEntity.getUserName());
        if (user == null) {
            res.setSuccess(false);
            res.setMessage("用户不存在,打卡失败");
            return res;
        }
        AttendanceManagement newAtte = new AttendanceManagement();
        String mag = "";
        // 设置用户编号
        newAtte.setUserId(user.getId());
        // 设置当前系统时间的当天开始时间
        newAtte.setTodayStart(DateUtils.getDateStart(new Date()));
        // 设置当前系统时间的当天结束时间
        newAtte.setTodayEnd(DateUtils.getDateEnd(new Date()));
        // 查询当前用户当天是否已打卡
        List<AttendanceManagement> oldAtteList = attendanceManagementService.findByUserNo(newAtte);
        AttendanceManagement oldAtte = null;
        // 打卡标志
        Boolean oprInsType = true;
        if (oldAtteList != null && oldAtteList.size() > 0) {
            // 如果是更新打卡，需要更新数据
            if ("2".equals(clockRequestEntity.getClockModel()) || "3".equals(clockRequestEntity.getClockModel())) {
                // 已打卡
                oprInsType = false;
            } else {
                // 最新的一条记录有下班打卡时间表示，已完成下班，再打卡需要插入新的打卡数据
                if (oldAtteList.get(0).getClockOutTime() != null) {
                    // 未打卡
                    oprInsType = true;
                } else {
                    // 已打卡
                    oprInsType = false;
                }
            }
            // 获取最新的一条打卡记录
            oldAtte = oldAtteList.get(0);
        }

        // 上班打卡
        // 更新上班打卡
        if ("0".equals(clockRequestEntity.getClockModel()) || "2".equals(clockRequestEntity.getClockModel())) {
            // 未打卡
            if (oprInsType) {
                // 设置打卡时间
                newAtte.setClockInTime(clockTime);
                // 设置上班打卡经度坐标
                newAtte.setInLongitude(clockRequestEntity.getLongitude());
                // 设置下班打卡纬度坐标
                newAtte.setInLatitude(clockRequestEntity.getLatitude());
                // 设置打卡位置
                newAtte.setInPosition(clockRequestEntity.getClockPosition());
                // 设置工作标准时长
                newAtte.setStandardWorkHours(STANDARD_WORK_HOURS);
                // 更新打卡考勤的状态
                Calendar ca = Calendar.getInstance();
                ca.setTime(clockTime);
                int hour = ca.get(Calendar.HOUR_OF_DAY);
                if (hour > 9 && ca.get(Calendar.MINUTE) > 1) { // 迟到
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_2);
                } else {
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_4);
                }
                // 未打卡，插入数据
                attendanceManagementService.save(newAtte);
                mag = "上班打卡成功";
            } else {
                // 设置打卡时间
                oldAtte.setClockInTime(clockTime);
                // 设置上班打卡经度坐标
                oldAtte.setInLongitude(clockRequestEntity.getLongitude());
                // 设置下班打卡纬度坐标
                oldAtte.setInLatitude(clockRequestEntity.getLatitude());
                // 设置打卡位置
                oldAtte.setInPosition(clockRequestEntity.getClockPosition());
                // 更新打卡考勤的状态
                Calendar ca = Calendar.getInstance();
                ca.setTime(clockTime);
                int hour = ca.get(Calendar.HOUR_OF_DAY);
                if (hour > 9 && ca.get(Calendar.MINUTE) > 1) { // 迟到
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_2);
                } else {
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_4);
                }
                // 已打卡，更新数据
                attendanceManagementService.update();
                mag = "更新上班打卡成功";
            }
        }
        // 下班打卡
        // 更新下班打卡
        if ("1".equals(clockRequestEntity.getClockModel()) || "3".equals(clockRequestEntity.getClockModel())) {
            // 未打卡
            if (oprInsType) {
                // 设置打卡时间
                newAtte.setClockOutTime(clockTime);
                // 设置上班打卡经度坐标
                newAtte.setOutLongitude(clockRequestEntity.getLongitude());
                // 设置下班打卡纬度坐标
                newAtte.setOutLatitude(clockRequestEntity.getLatitude());
                // 设置打卡位置
                newAtte.setOutPosition(clockRequestEntity.getClockPosition());
                // 设置工作标准时长
                newAtte.setStandardWorkHours(STANDARD_WORK_HOURS);
                // 更新打卡考勤的状态
                Calendar ca = Calendar.getInstance();
                ca.setTime(clockTime);
                int hour = ca.get(Calendar.HOUR_OF_DAY);
                if (hour < 17) { // 早退
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_3);
                } else {
                    newAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_1);
                }
                // 未打卡，插入数据
                attendanceManagementService.save(newAtte);
                mag = "下班打卡成功";
            } else {
                // 设置打卡时间
                oldAtte.setClockOutTime(clockTime);
                // 设置上班打卡经度坐标
                oldAtte.setOutLongitude(clockRequestEntity.getLongitude());
                // 设置下班打卡纬度坐标
                oldAtte.setOutLatitude(clockRequestEntity.getLatitude());
                // 设置打卡位置
                oldAtte.setOutPosition(clockRequestEntity.getClockPosition());
                double workHours = 0.0;
                if (oldAtte.getClockInTime() != null) {
                    // 计算加班时间
                    double dif = clockTime.getTime() - oldAtte.getClockInTime().getTime();
                    workHours = dif / (1000 * 60 * 60);

                }
                // 设置加班时长
                oldAtte.setWorkOverHours((workHours - 9) <= 0 ? 0 : (workHours - 9));
                // 设置工作总时长
                oldAtte.setWorkHours(workHours);
                // 更新打卡考勤的状态
                Calendar ca = Calendar.getInstance();
                ca.setTime(clockTime);
                int hour = ca.get(Calendar.HOUR_OF_DAY);
                // 只有当上班打卡时设置的考勤状态为【未打卡】时 ，下班时才会对状态做更新
                if (AttendanceManagement.ATTENDANCE_TYPE_4.equals(oldAtte.getAttendanceType())) {
                    if (hour < 17) { // 早退
                        oldAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_3);
                    } else {
                        oldAtte.setAttendanceType(AttendanceManagement.ATTENDANCE_TYPE_1);
                    }
                }
                // 已打卡，更新数据
                attendanceManagementService.updateAll(oldAtte);
                mag = "更新下班打卡成功";
            }
        }
        res.setSuccess(true);
        res.setMessage(mag);
        return res;
    }
}
